home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d954.lha / SCAN8800 / Example_in_C / SCAN8800_1.c < prev    next >
C/C++ Source or Header  |  1991-12-27  |  9KB  |  322 lines
  1. /**************************************************************************/
  2. /*** Programmname: "SCAN8800_1.c"     MIF-90                            ***/
  3. /*** Update      : vom 17.02.91                                         ***/
  4. /*** Beschreibung: Simple Steuerung des Empfängers FRG-8800 von YAESU   ***/
  5. /***               über das Interface MINIX MIF-90.                     ***/
  6. /*** Autor       : Rainer Redweik Kattowitzer Str. 7  D-3180 Wolfsburg 1***/
  7. /*** Version     : 1.0                                                  ***/
  8. /*** Computer    : AMIGA 500/1000/2000/3000T mit Kickstart 1.3/2.0      ***/
  9. /*** Compiler    : Aztec C V-5.0 with precompiled includefiles          ***/
  10. /***             : cc -ff -ps -so -wp -wu -hiInclude16.pre SCAN8800_1.c ***/
  11. /***             : ln SCAN8800_1.o +q -lmf16 -lc16                      ***/
  12. /**************************************************************************/
  13.  
  14. #include <functions.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #define WARTE           200L
  20. #define UNIT_NUMBER       0L  /* Multiple serial port */
  21. #define SER_BUFFER_SIZE   6
  22.  
  23.  
  24. /** TEXT --> unsigned char **/
  25.  
  26. /***************PROTOTYPES***********************************************/
  27. void oeffnen(void);
  28. void schliessen(void);
  29. void Serial_Read(void);
  30. void Serial_Write(void);
  31. LONG Freq_to_Buffer(LONG);
  32. void Set_Freq(LONG);
  33. /***************STRUCTUREN***********************************************/
  34. struct MsgPort       *SerialMP = 0L;       /* Für serial.device         */
  35. struct IOExtSer      *SerialIO = 0L;       /* Für serial.device         */
  36. /********************VARIABLE********************************************/
  37. TEXT  SerialBuffer[SER_BUFFER_SIZE] = "";
  38. LONG  OpenDevErr = -1;
  39.  
  40. /********************FUNCTIONEN******************************************/
  41.  
  42. void main(void)
  43. {
  44.  LONG i;
  45.  
  46.  oeffnen();
  47.  
  48.  printf("\fBaud: %ld\n\n", SerialIO->io_Baud);
  49.  
  50.  /* Fernb. ON */
  51.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x00,0x00);
  52.  Serial_Write();
  53.  Serial_Write();  /* Zur Sicherheit zweimal senden */
  54.  
  55.  /* Netz   ON */
  56.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0xfe,0x80);
  57.  Serial_Write();
  58.  
  59.  /* AM wide   */
  60.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x00,0x80);
  61.  Serial_Write();
  62.  
  63.  
  64.  Set_Freq(14254000L);
  65.  Delay(WARTE);
  66.  
  67.  
  68.  
  69.  printf("\n\n Scan MW with 9 kHz step\n");
  70.  
  71.  for(i = 522000; i <= 1611000L; i+=9000L) /* Scan MW with 9 KHz step */
  72.    Set_Freq(i);
  73.  
  74.  printf("\n\nScan part of MW with 25 Hz step\n");
  75.  
  76.  for(i = 1466500L; i <= 1467500L; i+=25L) /* Scan part of MW with 25 Hz step */
  77.    {
  78.     Set_Freq(i);
  79.     Delay(10L);
  80.    }
  81.  
  82.  Delay(WARTE);
  83.  
  84.  printf("\f10 MHz AM - wide:\n");
  85.  Set_Freq(10000000L);
  86.  
  87.  Delay(WARTE);
  88.  
  89.  printf("\f10 MHz AM - narr\n");
  90.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x08,0x80);
  91.  Serial_Write();
  92.  Delay(WARTE);
  93.  
  94.  printf("\f10 MHz LSB\n");
  95.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x01,0x80);
  96.  Serial_Write();
  97.  Delay(WARTE);
  98.  
  99.  printf("\f10 MHz CW - narr\n");
  100.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x0b,0x80);
  101.  Serial_Write();
  102.  Delay(WARTE);
  103.  
  104.  printf("\f10 MHz FM - narr\n");
  105.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x0c,0x80);
  106.  Serial_Write();
  107.  Delay(WARTE);
  108.  
  109.  printf("\f");
  110.  
  111.  /* Netz   OFF */
  112.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0xff,0x80);
  113.  Serial_Write();
  114.  
  115.  
  116.  printf("Empfänger auf 756 kHz einstellen.\n\n");
  117.  
  118.   /* Laut Beschreibung 2x die Frequenz senden */
  119.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x56,0x07,0x00,0x01);
  120.  Serial_Write();
  121.  Serial_Write();
  122.  
  123.  /* Fernb. OFF */
  124.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x80,0x00);
  125.  Serial_Write();
  126.  
  127.  printf("Der Empfänger sollte laut Beschreibung auf dieser Freq. eingestellt bleiben!\n\n");
  128.  
  129.  schliessen();
  130. }/* main() end*/
  131.  
  132.  
  133.  
  134.  
  135.  
  136. void oeffnen(void)
  137. {
  138.  if(!(SerialMP = CreatePort(0,0)))
  139.    {
  140.     printf("CreatePort failed \n");
  141.     schliessen();
  142.    }
  143.  
  144.  if(!(SerialIO = (struct IOExtSer *)CreateExtIO(SerialMP, sizeof(struct IOExtSer))))
  145.    {
  146.     printf("CreateExtIO failed \n");
  147.     schliessen();
  148.    }
  149.  
  150.  SerialIO->io_SerFlags = SERF_SHARED | SERF_XDISABLED;
  151.  
  152.  if((OpenDevErr = OpenDevice(SERIALNAME, UNIT_NUMBER, (struct IORequest *)SerialIO, 0L)) != 0L)
  153.    {
  154.     printf("Open-Device Error #%4lx  IOERR_OPENFAIL: %ld\n", OpenDevErr, (LONG)IOERR_OPENFAIL);
  155.     schliessen();
  156.    }
  157.  
  158.  
  159.  SerialIO->IOSer.io_Command = CMD_RESET;
  160.  SendIO((struct IORequest *)SerialIO);
  161.  
  162.  SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  163.  SerialIO->io_Baud          = 4800L;
  164.  SerialIO->io_ReadLen       = SerialIO->io_WriteLen = 8;
  165.  SerialIO->io_StopBits      = 2;
  166.  SendIO((struct IORequest *)SerialIO);
  167. }/* oeffnen() end */
  168.  
  169.  
  170.  
  171. void schliessen(void)
  172. {
  173.  if(SerialIO)
  174.    {
  175.     if(OpenDevErr == 0L)
  176.       {
  177.        AbortIO    ((struct IORequest *)SerialIO);
  178.        WaitIO     ((struct IORequest *)SerialIO);
  179.        CloseDevice((struct IORequest *)SerialIO);
  180.       }
  181.     DeleteExtIO((struct IORequest *)SerialIO);
  182.    }
  183.  
  184.  if(SerialMP) DeletePort((struct MsgPort*)SerialMP);
  185.  
  186.  exit(0);
  187. }/* schliessen() end */
  188.  
  189.  
  190.  
  191.  
  192.  
  193. void Serial_Read(void)
  194. {
  195.  LONG Temp;
  196.  ULONG WaitMask = SIGBREAKF_CTRL_C | 1L << SerialMP->mp_SigBit;
  197.  
  198.  /* Listing aus 'AMIGA ROMKERNEL Libraries&Devices Seite 863' */
  199.  SerialIO->IOSer.io_Command = CMD_READ;
  200.  SerialIO->IOSer.io_Length  = SER_BUFFER_SIZE;
  201.  SerialIO->IOSer.io_Data    = (APTR)&SerialBuffer[0];
  202.  SendIO((struct IORequest *)SerialIO);
  203.  
  204.  while(1)
  205.    {
  206.     Temp = Wait(WaitMask);
  207.  
  208.     if(SIGBREAKF_CTRL_C & Temp)
  209.       {
  210.        printf("Abbruch durch CTRL-C\n");
  211.        break;
  212.       }
  213.  
  214.     if( CheckIO((struct IORequest *)SerialIO) )
  215.       {
  216.        WaitIO((struct IORequest *)SerialIO);
  217. /*       printf("%ld bytes received\n", SerialIO->IOSer.io_Actual);*/
  218.        break;
  219.       }
  220.    }
  221.  
  222.  AbortIO((struct IORequest *)SerialIO);
  223.  WaitIO((struct IORequest *)SerialIO);
  224. }/* Serial_Read() end */
  225.  
  226.  
  227.  
  228. void Serial_Write(void)
  229. {
  230. /*************************************************************************/
  231. /* I am not glad about this part, but without this the programm dosn't   */
  232. /* work correct: only a few times of frequency-changes are possible.     */
  233.  
  234.  SerialIO->IOSer.io_Command = CMD_RESET;
  235.  DoIO((struct IORequest *)SerialIO);
  236.  
  237.  SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  238.  SerialIO->io_Baud          = 4800L;                        /* Baud Rate */
  239.  SerialIO->io_ReadLen       = SerialIO->io_WriteLen = 8;    /* Bits      */
  240.  SerialIO->io_StopBits      = 2;                            /* Stop-Bits */
  241.  DoIO((struct IORequest *)SerialIO);
  242. /*************************************************************************/
  243.  
  244.  Delay(7L);
  245.  SerialIO->IOSer.io_Command = CMD_WRITE;
  246.  SerialIO->IOSer.io_Length  = 5;
  247.  SerialIO->IOSer.io_Data    = (APTR)SerialBuffer;
  248.  DoIO((struct IORequest *)SerialIO);
  249. }/* Serial_Write() end */
  250.  
  251.  
  252.  
  253. LONG Freq_to_Buffer(LONG freq) /* Frequenz in die 4 Bytes umrechnen */
  254. {
  255.  int b1, b2, b3, b4, b5 = 1;
  256.  int zehner, liByte, reByte = 1;
  257.  
  258.    /* Frequency limits for FTZ-equipment */
  259.  if     (freq <    150000L) freq = 150000L;
  260.  else if(freq < 100000000L)
  261.    {
  262.     if(freq > 29999900L) freq = 29999900L;
  263.    }
  264.  else
  265.    {
  266.     if     (freq < 144000000L) freq = 144000000L;
  267.     else if(freq > 146000000L) freq = 146000000L;
  268.    }
  269.  
  270.  zehner = (int)(freq % 100L);
  271.  
  272.  if     (zehner < 13) {reByte = 1; freq = freq / 100L * 100L +  0L;}
  273.  else if(zehner < 38) {reByte = 2; freq = freq / 100L * 100L + 25L;}
  274.  else if(zehner < 68) {reByte = 4; freq = freq / 100L * 100L + 50L;}
  275.  else if(zehner < 88) {reByte = 8; freq = freq / 100L * 100L + 75L;}
  276.  else freq = freq / 100L * 100L + 100L;
  277.  
  278.  liByte = (int)((freq %   1000L) /      100L);   /* 100 Hz */
  279.  b1 = (liByte << 4) | reByte;
  280.  b2 = (int)((freq %     100000L) /     1000L);
  281.  b3 = (int)((freq %   10000000L) /   100000L);
  282.  b4 = (int)((freq % 1000000000L) / 10000000L);
  283.  
  284.  b2 = ((b2 / 10) << 4) + b2 % 10;  /* Umwandeln : Hex -> Dez */
  285.  b3 = ((b3 / 10) << 4) + b3 % 10;
  286.  b4 = ((b4 / 10) << 4) + b4 % 10;
  287.  
  288.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  b1, b2, b3, b4, b5);
  289.  return(freq);
  290. }/* Freq_to_Buffer() end */
  291.  
  292.  
  293.  
  294. void Set_Freq(LONG freq) /* Frequenz einstellen und Werte auslesen */
  295. {
  296.  float S_wert = 0.0F;
  297.  LONG frequenz;
  298.  int i, squelch;
  299.  
  300.  frequenz = Freq_to_Buffer(freq);
  301.  
  302.  printf("Freq.: %9ld Hz   %02x H  %02x H  %02x H  %02x H  %02x H   ", frequenz,
  303.         SerialBuffer[0],SerialBuffer[1],SerialBuffer[2],SerialBuffer[3],SerialBuffer[4]);
  304.  Serial_Write();
  305.  Serial_Read();
  306.  
  307.  
  308.   /* S-Wert: Mittelwert aus der Anzahl der empfangenen Messwerte */
  309.  for(i = 0; i < MAX(1,SerialIO->IOSer.io_Length); i++)
  310.    S_wert+=((float)(SerialBuffer[i] & 63) / 4.0F);
  311.  
  312.  S_wert/=MAX(1.0F, (float)SerialIO->IOSer.io_Length);
  313.  
  314.   /* Squelch erst beim 2ten Wert ([1]) ermitteln, da der erste Wert unzuverlässig ist */
  315.  squelch = ((SerialBuffer[1] & 64) >> 6);
  316.  
  317.  if(S_wert > 9.25F)
  318.    printf("S-Meter: 9 +%2d  SQ: %d\n", (int)(((S_wert-9.0F) * 10.0F)+2.5F)/5*5, squelch);
  319.  else
  320.    printf("S-Meter: %d      SQ: %d\n", (int)S_wert, squelch);
  321. }/* Set_Freq() end */
  322.